జావాస్క్రిప్ట్ అసింక్ ఇటరేటర్ హెల్పర్: ఫర్ ఈచ్ - స్ట్రీమ్ ప్రాసెసింగ్ ఇటరేషన్

ఆధునిక జావాస్క్రిప్ట్ అభివృద్ధికి అసమకాలిక ప్రోగ్రామింగ్ ఒక మూలస్తంభం, ఇది ప్రధాన థ్రెడ్‌ను నిరోధించకుండా సమయం తీసుకునే కార్యకలాపాలను నిర్వహించడానికి అనువర్తనాలను అనుమతిస్తుంది. ECMAScript 2018లో ప్రవేశపెట్టబడిన అసింక్ ఇటరేటర్లు, డేటా స్ట్రీమ్‌లను అసమకాలికంగా ప్రాసెస్ చేయడానికి శక్తివంతమైన యంత్రాంగాన్ని అందిస్తాయి. ఈ బ్లాగ్ పోస్ట్ అసింక్ ఇటరేటర్ల భావనను పరిశీలిస్తుంది మరియు స్ట్రీమ్ ప్రాసెసింగ్‌ను క్రమబద్ధీకరించడానికి అసమకాలిక 'ఫర్ ఈచ్' హెల్పర్ ఫంక్షన్‌ను ఎలా అమలు చేయాలో ప్రదర్శిస్తుంది.

అసింక్ ఇటరేటర్లను అర్థం చేసుకోవడం

అసింక్ ఇటరేటర్ అనేది AsyncIterator ఇంటర్‌ఫేస్‌కు అనుగుణంగా ఉండే ఒక ఆబ్జెక్ట్. ఇది ఒక next() మెథడ్‌ను నిర్వచిస్తుంది, ఇది ఒక ప్రామిస్‌ను అందిస్తుంది, ఇది రెండు ప్రాపర్టీలతో ఒక ఆబ్జెక్ట్‌కు రిసాల్వ్ అవుతుంది:

• విలువ: క్రమంలో తదుపరి విలువ.
• పూర్తయింది: ఇటరేటర్ పూర్తయిందో లేదో సూచించే బూలియన్.

నెట్‌వర్క్ స్ట్రీమ్‌లు, ఫైల్ సిస్టమ్‌లు లేదా డేటాబేస్‌ల వంటి అసమకాలిక వనరుల నుండి డేటాను వినియోగించడానికి అసింక్ ఇటరేటర్లను సాధారణంగా ఉపయోగిస్తారు. for await...of లూప్ అసింక్ ఇటరేబుల్స్ పై పునరావృతం చేయడానికి అనుకూలమైన సింటాక్స్‌ను అందిస్తుంది.

ఉదాహరణ: ఫైల్ నుండి అసమకాలికంగా చదవడం

మీరు ప్రధాన థ్రెడ్‌ను నిరోధించకుండా ఒక పెద్ద ఫైల్‌ను లైన్ ద్వారా లైన్ చదవాల్సిన పరిస్థితిని పరిగణించండి. మీరు దీన్ని ఒక అసింక్ ఇటరేటర్‌ను ఉపయోగించి సాధించవచ్చు:

            
const fs = require('fs');
const readline = require('readline');

async function* readFileLines(filePath) {
  const fileStream = fs.createReadStream(filePath);
  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });

  for await (const line of rl) {
    yield line;
  }
}

async function processFile(filePath) {
  for await (const line of readFileLines(filePath)) {
    console.log(`Line: ${line}`);
  }
}

// Example usage
processFile('path/to/your/file.txt');

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, readFileLines అనేది ఒక అసింక్ జెనరేటర్ ఫంక్షన్, ఇది ఫైల్‌లోని ప్రతి లైన్‌ను చదివినప్పుడు అందిస్తుంది. అప్పుడు processFile ఫంక్షన్ for await...of ఉపయోగించి లైన్‌లపై పునరావృతం చేస్తుంది, ప్రతి లైన్‌ను అసమకాలికంగా ప్రాసెస్ చేస్తుంది.

అసింక్ 'ఫర్ ఈచ్' హెల్పర్‌ను అమలు చేయడం

for await...of లూప్ ఉపయోగకరంగా ఉన్నప్పటికీ, స్ట్రీమ్‌లోని ప్రతి ఎలిమెంట్‌పై సంక్లిష్టమైన ఆపరేషన్‌లను నిర్వహించాల్సిన అవసరం వచ్చినప్పుడు ఇది వెర్బోస్ కావచ్చు. ఒక అసింక్ 'ఫర్ ఈచ్' హెల్పర్ ఫంక్షన్ ఇటరేషన్ లాజిక్‌ను ఎన్‌క్యాప్సులేట్ చేయడం ద్వారా ఈ ప్రక్రియను సులభతరం చేస్తుంది.

ప్రాథమిక అమలు

ఇక్కడ ఒక అసింక్ 'ఫర్ ఈచ్' ఫంక్షన్ యొక్క ప్రాథమిక అమలు ఉంది:

            
async function asyncForEach(iterable, callback) {
  for await (const item of iterable) {
    await callback(item);
  }
}

            

              
                Copy
              
            
          

ఈ ఫంక్షన్ ఒక అసింక్ ఇటరేబుల్ మరియు ఒక కాల్‌బ్యాక్ ఫంక్షన్‌ను ఆర్గ్యుమెంట్‌లుగా తీసుకుంటుంది. ఇది for await...of ఉపయోగించి ఇటరేబుల్ పై పునరావృతం చేస్తుంది మరియు ప్రతి ఐటమ్ కోసం కాల్‌బ్యాక్ ఫంక్షన్‌ను పిలుస్తుంది. మీరు తదుపరి ఐటమ్‌కు వెళ్లే ముందు దాని పూర్తి కోసం వేచి ఉండాలనుకుంటే కాల్‌బ్యాక్ ఫంక్షన్ కూడా అసమకాలికంగా ఉండాలి.

ఉదాహరణ: API నుండి డేటాను ప్రాసెస్ చేయడం

మీరు ఐటమ్స్ స్ట్రీమ్‌ను అందించే ఒక API నుండి డేటాను పొందుతున్నారని అనుకుందాం. మీరు ప్రతి ఐటమ్‌ను అది వచ్చినప్పుడు ప్రాసెస్ చేయడానికి అసింక్ 'ఫర్ ఈచ్' హెల్పర్‌ను ఉపయోగించవచ్చు:

            
async function* fetchDataStream(url) {
  const response = await fetch(url);
  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) {
        return;
      }

      // Assuming the API returns JSON chunks
      const chunk = decoder.decode(value);
      const items = JSON.parse(`[${chunk.replace(/\}\{/g, '},{')}]`); //Split chunks into valid json array

      for(const item of items){
        yield item;
      }
    }
  } finally {
    reader.releaseLock();
  }
}

async function processItem(item) {
  // Simulate an asynchronous operation
  await new Promise(resolve => setTimeout(resolve, 100));
  console.log(`Processing item: ${JSON.stringify(item)}`);
}

async function main() {
  const apiUrl = 'https://api.example.com/data'; // Replace with your API endpoint
  await asyncForEach(fetchDataStream(apiUrl), processItem);
  console.log('Finished processing data.');
}

// Example usage
main();

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, fetchDataStream API నుండి డేటాను పొందుతుంది మరియు ప్రతి ఐటమ్‌ను అది అందుకున్నప్పుడు అందిస్తుంది. processItem ఫంక్షన్ ప్రతి ఐటమ్‌పై ఒక అసమకాలిక ఆపరేషన్‌ను అనుకరిస్తుంది. అప్పుడు asyncForEach హెల్పర్ ఇటరేషన్ మరియు ప్రాసెసింగ్ లాజిక్‌ను సులభతరం చేస్తుంది.

మెరుగుదలలు మరియు పరిగణనలు

ఎర్రర్ హ్యాండ్లింగ్

అసమకాలిక పునరావృత్తి సమయంలో సంభవించే ఎర్రర్‌లను నిర్వహించడం చాలా ముఖ్యం. మీరు ఎక్సెప్షన్‌లను పట్టుకోవడానికి మరియు నిర్వహించడానికి కాల్‌బ్యాక్ ఫంక్షన్‌ను try...catch బ్లాక్‌లో చుట్టవచ్చు:

            
async function asyncForEach(iterable, callback) {
  for await (const item of iterable) {
    try {
      await callback(item);
    } catch (error) {
      console.error(`Error processing item: ${item}`, error);
      // You can choose to re-throw the error or continue processing
    }
  }
}

            

              
                Copy
              
            
          

కాన్‌కరెన్సీ కంట్రోల్

డిఫాల్ట్‌గా, అసింక్ 'ఫర్ ఈచ్' హెల్పర్ ఐటమ్స్‌ను వరుసగా ప్రాసెస్ చేస్తుంది. మీరు ఐటమ్స్‌ను ఏకకాలంలో ప్రాసెస్ చేయాలనుకుంటే, మీరు కాన్‌కరెంట్ ఆపరేషన్‌ల సంఖ్యను పరిమితం చేయడానికి ప్రామిస్ పూల్‌ను ఉపయోగించవచ్చు:

            
async function asyncForEachConcurrent(iterable, callback, concurrency) {
  const executing = [];
  for await (const item of iterable) {
    const p = callback(item).then(() => executing.splice(executing.indexOf(p), 1));
    executing.push(p);
    if (executing.length >= concurrency) {
      await Promise.race(executing);
    }
  }
  await Promise.all(executing);
}

async function processItem(item) {
  // Simulate an asynchronous operation
  await new Promise(resolve => setTimeout(resolve, 100));
  console.log(`Processing item: ${JSON.stringify(item)}`);
}

async function main() {
  const apiUrl = 'https://api.example.com/data'; // Replace with your API endpoint
  await asyncForEachConcurrent(fetchDataStream(apiUrl), processItem, 5); // Concurrency of 5
  console.log('Finished processing data.');
}

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, asyncForEachConcurrent ఏకకాలిక కాల్‌బ్యాక్ అమలుల సంఖ్యను పేర్కొన్న కాన్‌కరెన్సీ స్థాయికి పరిమితం చేస్తుంది. ఇది పెద్ద డేటా స్ట్రీమ్‌లతో వ్యవహరించేటప్పుడు పనితీరును మెరుగుపరుస్తుంది.

రద్దుచేయడం

కొన్ని సందర్భాల్లో, మీరు ఇటరేషన్ ప్రక్రియను ముందుగానే రద్దు చేయాల్సి రావచ్చు. మీరు దీన్ని AbortController ఉపయోగించి సాధించవచ్చు:

            
async function asyncForEach(iterable, callback, signal) {
  for await (const item of iterable) {
    if (signal && signal.aborted) {
      console.log('Iteration aborted.');
      return;
    }
    await callback(item);
  }
}

async function main() {
  const controller = new AbortController();
  const signal = controller.signal;

  setTimeout(() => {
    controller.abort(); // Abort after 2 seconds
  }, 2000);

  const apiUrl = 'https://api.example.com/data'; // Replace with your API endpoint
  await asyncForEach(fetchDataStream(apiUrl), processItem, signal);
  console.log('Finished processing data.');
}

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, asyncForEach ఫంక్షన్ ప్రతి పునరావృత్తికి ముందు signal.aborted ప్రాపర్టీని తనిఖీ చేస్తుంది. సిగ్నల్ రద్దు చేయబడితే, పునరావృత్తి ఆపివేయబడుతుంది.

వాస్తవ-ప్రపంచ అనువర్తనాలు

అసింక్ ఇటరేటర్లు మరియు అసింక్ 'ఫర్ ఈచ్' హెల్పర్‌ను విస్తృత శ్రేణి వాస్తవ-ప్రపంచ దృశ్యాలకు అన్వయించవచ్చు:

• డేటా ప్రాసెసింగ్ పైప్‌లైన్‌లు: డేటాబేస్‌లు లేదా ఫైల్ సిస్టమ్‌ల నుండి పెద్ద డేటాసెట్‌లను ప్రాసెస్ చేయడం.
• రియల్-టైమ్ డేటా స్ట్రీమ్‌లు: వెబ్ సాకెట్‌లు, మెసేజ్ క్యూలు లేదా సెన్సార్ నెట్‌వర్క్‌ల నుండి డేటాను నిర్వహించడం.
• API వినియోగం: ఐటమ్స్ స్ట్రీమ్‌లను అందించే APIల నుండి డేటాను పొందడం మరియు ప్రాసెస్ చేయడం.
• చిత్రం మరియు వీడియో ప్రాసెసింగ్: పెద్ద మీడియా ఫైల్‌లను ముక్కలుగా ప్రాసెస్ చేయడం.
• లాగ్ విశ్లేషణ: పెద్ద లాగ్ ఫైల్‌లను లైన్ ద్వారా లైన్ విశ్లేషించడం.

ఉదాహరణ - అంతర్జాతీయ స్టాక్ డేటా: వివిధ అంతర్జాతీయ ఎక్స్ఛేంజ్‌ల నుండి రియల్-టైమ్ స్టాక్ కోట్‌లను పొందే ఒక అప్లికేషన్‌ను పరిగణించండి. డేటాను స్ట్రీమ్ చేయడానికి ఒక అసింక్ ఇటరేటర్‌ను ఉపయోగించవచ్చు, మరియు ఒక అసింక్ 'ఫర్ ఈచ్' ప్రతి కోట్‌ను ప్రాసెస్ చేయగలదు, వినియోగదారు ఇంటర్‌ఫేస్‌ను తాజా ధరలతో నవీకరిస్తుంది. దీనిని ఈ క్రింది కంపెనీల ప్రస్తుత స్టాక్ రేట్లను ప్రదర్శించడానికి ఉపయోగించవచ్చు:

• టెన్సెంట్ (చైనా): ఒక ప్రధాన అంతర్జాతీయ టెక్నాలజీ కంపెనీ యొక్క స్టాక్ డేటాను పొందడం
• టాటా కన్సల్టెన్సీ సర్వీసెస్ (భారతదేశం): ఒక ప్రముఖ IT సేవల కంపెనీ నుండి స్టాక్ నవీకరణలను ప్రదర్శించడం
• శామ్‌సంగ్ ఎలక్ట్రానిక్స్ (దక్షిణ కొరియా): ఒక గ్లోబల్ ఎలక్ట్రానిక్స్ తయారీదారు నుండి స్టాక్ రేట్లను ప్రదర్శించడం
• టయోటా మోటార్ కార్పొరేషన్ (జపాన్): ఒక అంతర్జాతీయ ఆటో తయారీదారు యొక్క స్టాక్ ధరలను పర్యవేక్షించడం

ముగింపు

అసింక్ ఇటరేటర్లు మరియు అసింక్ 'ఫర్ ఈచ్' హెల్పర్ జావాస్క్రిప్ట్‌లో అసమకాలికంగా డేటా స్ట్రీమ్‌లను ప్రాసెస్ చేయడానికి ఒక శక్తివంతమైన మరియు సొగసైన మార్గాన్ని అందిస్తాయి. ఇటరేషన్ లాజిక్‌ను ఎన్‌క్యాప్సులేట్ చేయడం ద్వారా, మీరు మీ కోడ్‌ను సులభతరం చేయవచ్చు, చదవడానికి వీలుగా మెరుగుపరచవచ్చు మరియు మీ అప్లికేషన్‌ల పనితీరును పెంచవచ్చు. ఎర్రర్‌లను నిర్వహించడం, కాన్‌కరెన్సీని నియంత్రించడం మరియు రద్దు చేయడాన్ని ప్రారంభించడం ద్వారా, మీరు దృఢమైన మరియు స్కేలబుల్ అసమకాలిక డేటా ప్రాసెసింగ్ పైప్‌లైన్‌లను సృష్టించవచ్చు.

మరింత నేర్చుకోవడం

• MDN వెబ్ డాక్స్: for await...of
• MDN వెబ్ డాక్స్: async function*
• ECMAScript స్పెసిఫికేషన్: AsyncIterator ఇంటర్‌ఫేస్